package com.bm.specialvehiclefordispatcher;

import java.io.File;
import java.util.List;

import android.app.Application;
import android.content.Context;
import android.os.Build;
import android.os.Environment;
import android.os.Handler;
import cn.jpush.android.api.JPushInterface;

import com.baidu.location.BDLocation;
import com.baidu.location.BDLocationListener;
import com.baidu.location.LocationClient;
import com.baidu.location.LocationClientOption;
import com.baidu.location.LocationClientOption.LocationMode;
import com.baidu.mapapi.SDKInitializer;
import com.baidu.mapapi.model.LatLng;
import com.bm.corelibs.Configuration;
import com.bm.corelibs.http.RequestManager;
import com.bm.corelibs.utils.MethodsCompat;
import com.bm.corelibs.utils.SharedPreferencesUtil;
import com.bm.corelibs.utils.ToastMgr;
import com.bm.specialvehiclefordispatcher.bean.TruckStyle1;
import com.bm.specialvehiclefordispatcher.constants.Constant;

public class App extends Application {
	
	public static List<TruckStyle1> TruckStyleList;
	public static int ownerStatus = 1;
	static App instance;
	Double Latitude;
	Double Longitude;
	private LatLng latLng;

	public final boolean isDebug = false;// 是否为调试模式

	/**
	 * 是否打开水印
	 */
	private boolean isOpenWaterMark = true;

	Handler mHandler;

	SharedPreferencesUtil sp;

	public LocationClient mLocationClient = null;
	public BDLocationListener myListener = new MyLocationListener();

	public void setHandler(Handler handler) {
		mHandler = handler;
	}

	public boolean getIsOpenWaterMark() {
		return isOpenWaterMark;
	}

	public App() {
		instance = this;
	}

	public static synchronized App getInstance() {
		return instance;
	}

	@Override
	public void onCreate() {
		super.onCreate();
		JPushInterface.setDebugMode(true);
		JPushInterface.init(this);
		init();
	}

	private void init() {
		RequestManager.init(this, Constant.VOLLEY_CACHE_PATH);
		ToastMgr.init(this);
		Configuration.setShowNetworkJson(true);
		Configuration.setShowNetworkParams(true);
		mLocationClient = new LocationClient(getApplicationContext()); // 声明LocationClient类
		mLocationClient.registerLocationListener(myListener); // 注册监听函数
		SDKInitializer.initialize(getApplicationContext());
		
		 initLocation();
		 mLocationClient.start();
	}

	protected void initLocation() {
		LocationClientOption option = new LocationClientOption();
		option.setLocationMode(LocationMode.Hight_Accuracy);// 可选，默认高精度，设置定位模式，高精度，低功耗，仅设备
		option.setCoorType("bd09ll");// 可选，默认gcj02，设置返回的定位结果坐标系
		int span = 1000;
		option.setScanSpan(span);// 可选，默认0，即仅定位一次，设置发起定位请求的间隔需要大于等于1000ms才是有效的
		option.setIsNeedAddress(true);// 可选，设置是否需要地址信息，默认不需要
		option.setOpenGps(true);// 可选，默认false,设置是否使用gps
		option.setLocationNotify(true);// 可选，默认false，设置是否当gps有效时按照1S1次频率输出GPS结果
		option.setIsNeedLocationDescribe(true);// 可选，默认false，设置是否需要位置语义化结果，可以在BDLocation.getLocationDescribe里得到，结果类似于“在北京天安门附近”
		option.setIsNeedLocationPoiList(true);// 可选，默认false，设置是否需要POI结果，可以在BDLocation.getPoiList里得到
		option.setIgnoreKillProcess(false);// 可选，默认false，定位SDK内部是一个SERVICE，并放到了独立进程，设置是否在stop的时候杀死这个进程，默认杀死
		option.SetIgnoreCacheException(false);// 可选，默认false，设置是否收集CRASH信息，默认收集
		option.setEnableSimulateGps(false);// 可选，默认false，设置是否需要过滤gps仿真结果，默认需要
		mLocationClient.setLocOption(option);
	}

	/**
	 * 清除app缓存
	 */
	public void clearAppCache(Context context) throws Exception {
		// 清除数据缓存，分别为files、SD卡、data、数据库
		clearCacheFolder(getFilesDir(), System.currentTimeMillis());
		clearCacheFolder(new File(getDiscCacheDir(context)),
				System.currentTimeMillis());
		clearCacheFolder(getCacheDir(), System.currentTimeMillis());
		// clearCacheFolder(new
		// File("/data/data/com.bm.lingtaozhisheng/databases"),
		// System.currentTimeMillis());
		// 2.2版本才有将应用缓存转移到sd卡的功能
		if (isMethodsCompat(android.os.Build.VERSION_CODES.FROYO)) {
			clearCacheFolder(MethodsCompat.getExternalCacheDir(this),
					System.currentTimeMillis());
		}
	}

	public Double getLatitude() {

		return this.Latitude;
	}

	public Double getLongitude() {

		return this.Longitude;
	}

	public void resetLatLng() {
		mLocationClient.start();
	}

	public LatLng getLatLng() {
		return latLng;
	}

	/**
	 * 获取SD卡上的缓存路径
	 * 
	 * @param context
	 * @return
	 */
	private static String getDiscCacheDir(Context context) {
		// android 2.2 以后才支持的特性
		if (hasExternalCacheDir()) {
			// 内存卡可用时
			if (sdCardIsAvailable()) {
				return context.getExternalCacheDir().getPath();
			}
		}
		// Before Froyo we need to construct the external cache dir ourselves
		// 2.2以前我们需要自己构造
		final String cacheDir = "/Android/data/" + context.getPackageName()
				+ "/cache/";
		return Environment.getExternalStorageDirectory().getPath() + cacheDir;
	}

	/**
	 * 清除缓存目录
	 * 
	 * @param dir
	 *            目录
	 * @param numDays
	 *            当前系统时间
	 * @return
	 */
	private int clearCacheFolder(File dir, long curTime) {
		int deletedFiles = 0;
		if (dir != null && dir.isDirectory()) {
			try {
				for (File child : dir.listFiles()) {
					if (child.isDirectory()) {
						deletedFiles += clearCacheFolder(child, curTime);
					}
					if (child.lastModified() < curTime) {
						if (child.delete()) {
							deletedFiles++;
						}
					}
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		return deletedFiles;
	}

	/**
	 * 判断当前版本是否兼容目标版本的方法
	 * 
	 * @param VersionCode
	 * @return
	 */
	public static boolean isMethodsCompat(int VersionCode) {
		int currentVersion = android.os.Build.VERSION.SDK_INT;
		return currentVersion >= VersionCode;
	}

	public static boolean hasExternalCacheDir() {
		return Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO;
	}

	/**
	 * 检测sdcard是否可用
	 * 
	 * @return true为可用，否则为不可用
	 */
	public static boolean sdCardIsAvailable() {
		String status = Environment.getExternalStorageState();
		if (!status.equals(Environment.MEDIA_MOUNTED)) {
			return false;
		}
		return true;
	}

	public class MyLocationListener implements BDLocationListener {

		@Override
		public void onReceiveLocation(BDLocation location) {
			latLng = new LatLng(location.getLatitude(), location.getLongitude());
			Longitude = location.getLongitude();
			Latitude = location.getLatitude();

			if (location.getLocationDescribe() != null) {
				mLocationClient.stop();
			}
		}
	}

}
